<!DOCTYPE html>
<html lang="en">
<head>
    <title>python-magic-methods</title>
    <meta charset="UTF-8">
    <meta name="description" content="ltoddy's blog">
    <meta name="author" content="liutao">
    <meta name="author" content="ltoddy">
    <meta name="author" content="just for fun">

    <!-- 最新版本的 Bootstrap 核心 CSS 文件 -->
    <link rel="stylesheet" href="https://cdn.bootcss.com/bootstrap/3.3.7/css/bootstrap.min.css"
          integrity="sha384-BVYiiSIFeK1dGmJRAkycuHAHRg32OmUcww7on3RYdg4Va+PmSTsz/K68vbdEjh4u" crossorigin="anonymous">

    <!-- jQuert Microsoft CDN -->
    <script src="https://ajax.aspnetcdn.com/ajax/jQuery/jquery-3.3.1.min.js"></script>
    <!-- 最新的 Bootstrap 核心 JavaScript 文件 -->
    <script src="https://cdn.bootcss.com/bootstrap/3.3.7/js/bootstrap.min.js"
            integrity="sha384-Tc5IQib027qvyjSMfHjOMaLkfuWVxZxUPnCJA7l2mCWNIpG9mGCD8wGNIcPD7Txa"
            crossorigin="anonymous"></script>
</head>
<body>

<div class="container">
    <h1><a id="Python__0"></a>Python 魔法方法</h1>
    <h3><a id="_2"></a>基础:</h3>
    <table class="table table-striped table-bordered">
        <thead>
        <tr>
            <th>如果你想…</th>
            <th>所以,你写…</th>
            <th>Python调用…</th>
        </tr>
        </thead>
        <tbody>
        <tr>
            <td>初始化一个实例</td>
            <td><code>x = MyClass()</code></td>
            <td><code>x.__init__()</code></td>
        </tr>
        <tr>
            <td>作为一个字符串的&quot;官方&quot;表示</td>
            <td><code>repr(x)</code></td>
            <td><code>x.__repr__()</code></td>
        </tr>
        <tr>
            <td>作为一个字符串</td>
            <td><code>str(x)</code></td>
            <td><code>x.__str__()</code></td>
        </tr>
        <tr>
            <td>作为字节数组</td>
            <td><code>bytes(x)</code></td>
            <td><code>x.__bytes__()</code></td>
        </tr>
        <tr>
            <td>作为格式化字符串</td>
            <td><code>format(x, format_spec)</code></td>
            <td><code>x.__format__(format_spec)</code></td>
        </tr>
        </tbody>
    </table>
    <ul>
        <li><code>__init__()</code>方法在创建实例后调用.如果你想控制创建过程,请使用<code>__new__()</code>方法</li>
        <li>按照惯例, <code>__repr__()</code> 应该返回一个有效的Python表达式的字符串</li>
        <li><code>__str__()</code>方法也被称为你的<code>print(x)</code></li>
    </ul>
    <h3><a id="_17"></a>迭代相关</h3>
    <table class="table table-striped table-bordered">
        <thead>
        <tr>
            <th>如果你想…</th>
            <th>所以,你写…</th>
            <th>Python调用…</th>
        </tr>
        </thead>
        <tbody>
        <tr>
            <td>遍历一个序列</td>
            <td><code>iter(seq)</code></td>
            <td><code>seq.__iter__()</code></td>
        </tr>
        <tr>
            <td>从迭代器中获取下一个值</td>
            <td><code>next(seq)</code></td>
            <td><code>seq.__next__()</code></td>
        </tr>
        <tr>
            <td>以相反的顺序创建一个迭代器</td>
            <td><code>reversed(seq)</code></td>
            <td><code>seq.__reversed__()</code></td>
        </tr>
        </tbody>
    </table>
    <ul>
        <li><code>__iter__()</code>无论何时创建新的迭代器,都会调用该方法.</li>
        <li><code>__next__()</code>每当你从迭代器中检索一下个值的时候,都会调用该方法</li>
        <li><code>__reversed__()</code>方法并不常见.它需要一个现有序列并返回一个迭代器,该序列是倒序的顺序.</li>
    </ul>
    <h3><a id="_29"></a>属性</h3>
    <table class="table table-striped table-bordered">
        <thead>
        <tr>
            <th>如果你想…</th>
            <th>所以,你写…</th>
            <th>Python调用…</th>
        </tr>
        </thead>
        <tbody>
        <tr>
            <td>得到一个属性</td>
            <td><code>x.my_property</code></td>
            <td><code>x.__getattribute__('my_property')</code></td>
        </tr>
        <tr>
            <td>获得一个属性</td>
            <td><code>x.my_property</code></td>
            <td><code>x.__getattr__('my_property')</code></td>
        </tr>
        <tr>
            <td>设置一个属性</td>
            <td><code>x.my_property = value</code></td>
            <td><code>x.__setattr__('my_property', value)</code></td>
        </tr>
        <tr>
            <td>删除一个属性</td>
            <td><code>del x.my_property</code></td>
            <td><code>x.__delattr__('my_property')</code></td>
        </tr>
        <tr>
            <td>列出所有属性和方法</td>
            <td><code>dir(x)</code></td>
            <td><code>x.__dir__()</code></td>
        </tr>
        </tbody>
    </table>
    <ul>
        <li>如果你的类定义了一个<code>__getattribute__()</code>方法,Python将在每次引用任何属性或方法名时调用它.</li>
        <li>如果你的类定义了一个<code>__getattr__()</code>方法,Python只会在所有普通地方查找属性后调用它.如果一个实例<code>x</code>定义了一个属性
            <code>color</code>, <code>x.color</code>将不会调用<code>x.__getattr__('color')</code>;
            它将简单地返回已经定义的<code>x.color</code>值.
        </li>
        <li><code>__setattr__()</code>只要你为属性指定值,就会调用该方法.</li>
        <li><code>__delattr__()</code>只要删除属性,就会调用该方法.</li>
        <li><code>__dir__()</code>如果您定义一个<code>__getattr__()</code> 或者 <code>__getattribute__()</code>
            方法,该方法很有用.通常情况下,调用<code>dir(x)</code>只会列出常规属性和方法.
        </li>
    </ul>
    <p><strong><em><code>__getattr__()</code>和<code>__getattribute__()</code>方法之间的区别很微妙但很重要.</em></strong></p>
    <h3><a id="_48"></a>函数类</h3>
    <p>通过定义__call__()方法,您可以创建一个可调用类的实例 - 就像函数可调用一样.</p>
    <table class="table table-striped table-bordered">
        <thead>
        <tr>
            <th>如果你想…</th>
            <th>所以,你写…</th>
            <th>Python调用…</th>
        </tr>
        </thead>
        <tbody>
        <tr>
            <td>来&quot;调用&quot;像函数一样的实例</td>
            <td><code>my_instance()</code></td>
            <td><code>my_instance.__call__()</code></td>
        </tr>
        </tbody>
    </table>
    <h3><a id="_56"></a>行为</h3>
    <p>如果你的类作为一组值的容器 - 也就是说,如果问你的类是否&quot;包含&quot;一个值是有意义的 - 那么它应该定义下面的特殊方法,使它像一个集合一样.</p>
    <table class="table table-striped table-bordered">
        <thead>
        <tr>
            <th>如果你想…</th>
            <th>所以,你写…</th>
            <th>Python调用…</th>
        </tr>
        </thead>
        <tbody>
        <tr>
            <td>序列的数量</td>
            <td><code>len(s)</code></td>
            <td><code>s.__len__()</code></td>
        </tr>
        <tr>
            <td>否包含特定的值</td>
            <td><code>x in s</code></td>
            <td><code>s.__contains__(x)</code></td>
        </tr>
        </tbody>
    </table>
    <h3><a id="_65"></a>字典(映射)</h3>
    <table class="table table-striped table-bordered">
        <thead>
        <tr>
            <th>如果你想…</th>
            <th>所以,你写…</th>
            <th>Python调用…</th>
        </tr>
        </thead>
        <tbody>
        <tr>
            <td>通过它的key来获得值</td>
            <td><code>x[key]</code></td>
            <td><code>x.__getitem__(key)</code></td>
        </tr>
        <tr>
            <td>通过它的key来设置一个值</td>
            <td><code>x[key] = value</code></td>
            <td><code>x.__setitem__(key, value)</code></td>
        </tr>
        <tr>
            <td>删除键值对</td>
            <td><code>del x[key]</code></td>
            <td><code>x.__delitem__(key)</code></td>
        </tr>
        <tr>
            <td>为丢失的key提供默认值</td>
            <td><code>x[nonexistent_key]</code></td>
            <td><code>x.__missing__(nonexistent_key)</code></td>
        </tr>
        </tbody>
    </table>
    <h3><a id="_75"></a>数字</h3>
    <table class="table table-striped table-bordered">
        <thead>
        <tr>
            <th>如果你想…</th>
            <th>所以,你写…</th>
            <th>Python调用…</th>
        </tr>
        </thead>
        <tbody>
        <tr>
            <td>加</td>
            <td><code>x + y</code></td>
            <td><code>x.__add__(y)</code></td>
        </tr>
        <tr>
            <td>减</td>
            <td><code>x - y</code></td>
            <td><code>x.__sub__(y)</code></td>
        </tr>
        <tr>
            <td>乘</td>
            <td><code>x * y</code></td>
            <td><code>x.__mul__(y)</code></td>
        </tr>
        <tr>
            <td>整除</td>
            <td><code>x / y</code></td>
            <td><code>x.__trueiv__(y)</code></td>
        </tr>
        <tr>
            <td>除</td>
            <td><code>x // y</code></td>
            <td><code>x.__floordiv__(v)</code></td>
        </tr>
        <tr>
            <td>取余</td>
            <td><code>x % y</code></td>
            <td><code>x.__mod__(y)</code></td>
        </tr>
        <tr>
            <td>整除与取余</td>
            <td><code>divmod(x, y)</code></td>
            <td><code>x.__divmod__(y)</code></td>
        </tr>
        <tr>
            <td>平方</td>
            <td><code>x ** y</code></td>
            <td><code>x.__pow__(y)</code></td>
        </tr>
        <tr>
            <td>左移</td>
            <td><code>x &lt;&lt; y</code></td>
            <td><code>x.__lshift__(y)</code></td>
        </tr>
        <tr>
            <td>右移</td>
            <td><code>x &gt;&gt; y</code></td>
            <td><code>x.__rshift__(y)</code></td>
        </tr>
        <tr>
            <td>按位and运算</td>
            <td><code>x &amp; y</code></td>
            <td><code>x.__and__(y)</code></td>
        </tr>
        <tr>
            <td>按位xor或运算</td>
            <td><code>x ^ y</code></td>
            <td><code>x.__xor__(y)</code></td>
        </tr>
        <tr>
            <td>按位or运算</td>
            <td><code>x | y</code></td>
            <td><code>x.__or__(y)</code></td>
        </tr>
        </tbody>
    </table>
    <p>上述一组特殊方法采用第一种方法:给定<code>x / y</code>,它们提供了一种方法让<code>x</code>说&quot;我知道如何用<code>y</code>整除自己&quot;.以下一组特殊方法解决了第二种方法:它们为y提供了一种方法来说&quot;我知道如何成为分母,并将自己整除x&quot;.
    </p>
    <table class="table table-striped table-bordered">
        <thead>
        <tr>
            <th>如果你想…</th>
            <th>所以,你写…</th>
            <th>Python调用…</th>
        </tr>
        </thead>
        <tbody>
        <tr>
            <td>加</td>
            <td><code>x + y</code></td>
            <td><code>x.__radd__(y)</code></td>
        </tr>
        <tr>
            <td>减</td>
            <td><code>x - y</code></td>
            <td><code>x.__rsub__(y)</code></td>
        </tr>
        <tr>
            <td>乘</td>
            <td><code>x * y</code></td>
            <td><code>x.__rmul__(y)</code></td>
        </tr>
        <tr>
            <td>整除</td>
            <td><code>x / y</code></td>
            <td><code>x.__rtrueiv__(y)</code></td>
        </tr>
        <tr>
            <td>除</td>
            <td><code>x // y</code></td>
            <td><code>x.__rfloordiv__(v)</code></td>
        </tr>
        <tr>
            <td>取余</td>
            <td><code>x % y</code></td>
            <td><code>x.__rmod__(y)</code></td>
        </tr>
        <tr>
            <td>整除与取余</td>
            <td><code>divmod(x, y)</code></td>
            <td><code>x.__rdivmod__(y)</code></td>
        </tr>
        <tr>
            <td>平方</td>
            <td><code>x ** y</code></td>
            <td><code>x.__rpow__(y)</code></td>
        </tr>
        <tr>
            <td>左移</td>
            <td><code>x &lt;&lt; y</code></td>
            <td><code>x.__rlshift__(y)</code></td>
        </tr>
        <tr>
            <td>右移</td>
            <td><code>x &gt;&gt; y</code></td>
            <td><code>x.__rrshift__(y)</code></td>
        </tr>
        <tr>
            <td>按位and运算</td>
            <td><code>x &amp; y</code></td>
            <td><code>x.__rand__(y)</code></td>
        </tr>
        <tr>
            <td>按位xor或运算</td>
            <td><code>x ^ y</code></td>
            <td><code>x.__rxor__(y)</code></td>
        </tr>
        <tr>
            <td>按位or运算</td>
            <td><code>x | y</code></td>
            <td><code>x.__ror__(y)</code></td>
        </tr>
        </tbody>
    </table>
    <p>可是等等！还有更多！如果你正在进行&quot;就地&quot;操作,如<code>x /= 3</code>则可以定义更多特殊的方法.</p>
    <table class="table table-striped table-bordered">
        <thead>
        <tr>
            <th>如果你想…</th>
            <th>所以,你写…</th>
            <th>Python调用…</th>
        </tr>
        </thead>
        <tbody>
        <tr>
            <td>加</td>
            <td><code>x + y</code></td>
            <td><code>x.__iadd__(y)</code></td>
        </tr>
        <tr>
            <td>减</td>
            <td><code>x - y</code></td>
            <td><code>x.__isub__(y)</code></td>
        </tr>
        <tr>
            <td>乘</td>
            <td><code>x * y</code></td>
            <td><code>x.__imul__(y)</code></td>
        </tr>
        <tr>
            <td>整除</td>
            <td><code>x / y</code></td>
            <td><code>x.__itrueiv__(y)</code></td>
        </tr>
        <tr>
            <td>除</td>
            <td><code>x // y</code></td>
            <td><code>x.__ifloordiv__(v)</code></td>
        </tr>
        <tr>
            <td>取余</td>
            <td><code>x % y</code></td>
            <td><code>x.__imod__(y)</code></td>
        </tr>
        <tr>
            <td>整除与取余</td>
            <td><code>divmod(x, y)</code></td>
            <td><code>x.__idivmod__(y)</code></td>
        </tr>
        <tr>
            <td>平方</td>
            <td><code>x ** y</code></td>
            <td><code>x.__ipow__(y)</code></td>
        </tr>
        <tr>
            <td>左移</td>
            <td><code>x &lt;&lt; y</code></td>
            <td><code>x.__ilshift__(y)</code></td>
        </tr>
        <tr>
            <td>右移</td>
            <td><code>x &gt;&gt; y</code></td>
            <td><code>x.__irshift__(y)</code></td>
        </tr>
        <tr>
            <td>按位and运算</td>
            <td><code>x &amp; y</code></td>
            <td><code>x.__iand__(y)</code></td>
        </tr>
        <tr>
            <td>按位xor或运算</td>
            <td><code>x ^ y</code></td>
            <td><code>x.__ixor__(y)</code></td>
        </tr>
        <tr>
            <td>按位or运算</td>
            <td><code>x | y</code></td>
            <td><code>x.__ior__(y)</code></td>
        </tr>
        </tbody>
    </table>
    <p>还有一些&quot;单个数&quot;数学运算可以让你自己对类似数字的对象进行数学运算.</p>
    <table class="table table-striped table-bordered">
        <thead>
        <tr>
            <th>如果你想…</th>
            <th>所以,你写…</th>
            <th>Python调用…</th>
        </tr>
        </thead>
        <tbody>
        <tr>
            <td>负数</td>
            <td><code>-x</code></td>
            <td><code>x.__neg__()</code></td>
        </tr>
        <tr>
            <td>正数</td>
            <td><code>+x</code></td>
            <td><code>x.__pos__()</code></td>
        </tr>
        <tr>
            <td>绝对值</td>
            <td><code>abs(x)</code></td>
            <td><code>x.__abs__()</code></td>
        </tr>
        <tr>
            <td>逆</td>
            <td><code>~x</code></td>
            <td><code>x.__invert__()</code></td>
        </tr>
        <tr>
            <td>复数</td>
            <td><code>complex(x)</code></td>
            <td><code>x.__complex__()</code></td>
        </tr>
        <tr>
            <td>整数</td>
            <td><code>int(x)</code></td>
            <td><code>x.__int__()</code></td>
        </tr>
        <tr>
            <td>浮点数</td>
            <td><code>float(x)</code></td>
            <td><code>x.__float__()</code></td>
        </tr>
        <tr>
            <td>四舍五入到最近的整数</td>
            <td><code>round(x)</code></td>
            <td><code>x.__round__()</code></td>
        </tr>
        <tr>
            <td>四舍五入到最近的n位数</td>
            <td><code>round(x, n)</code></td>
            <td><code>x.__round__(n)</code></td>
        </tr>
        <tr>
            <td>最小整数</td>
            <td><code>math.ceil(x)</code></td>
            <td><code>x.__ceil__()</code></td>
        </tr>
        <tr>
            <td>最大整数</td>
            <td><code>math.floor(x)</code></td>
            <td><code>x.__floor__()</code></td>
        </tr>
        <tr>
            <td>截断x到0的最接近的整数</td>
            <td><code>math.trunc(x)</code></td>
            <td><code>x.__trunc__()</code></td>
        </tr>
        <tr>
            <td>数字作为列表索引</td>
            <td><code>a_list[x]</code></td>
            <td><code>a_list[x.__index__()]</code></td>
        </tr>
        </tbody>
    </table>
    <h3><a id="_147"></a>比较</h3>
    <table class="table table-striped table-bordered">
        <thead>
        <tr>
            <th>如果你想…</th>
            <th>所以,你写…</th>
            <th>Python调用…</th>
        </tr>
        </thead>
        <tbody>
        <tr>
            <td>等于</td>
            <td><code>x == y</code></td>
            <td><code>x.__eq__(y)</code></td>
        </tr>
        <tr>
            <td>不等于</td>
            <td><code>x != y</code></td>
            <td><code>x.__ne__(y)</code></td>
        </tr>
        <tr>
            <td>小于</td>
            <td><code>x &lt; y</code></td>
            <td><code>x.__lt__(y)</code></td>
        </tr>
        <tr>
            <td>小于等于</td>
            <td><code>x &lt;= y</code></td>
            <td><code>x.__le__(y)</code></td>
        </tr>
        <tr>
            <td>大于</td>
            <td><code>x &gt; y</code></td>
            <td><code>x.__gt__(y)</code></td>
        </tr>
        <tr>
            <td>大于等于</td>
            <td><code>x &gt;= y</code></td>
            <td><code>x.__ge__(y)</code></td>
        </tr>
        <tr>
            <td>布尔</td>
            <td><code>if x:</code></td>
            <td><code>x.__bool__()</code></td>
        </tr>
        </tbody>
    </table>
    <h3><a id="_159"></a>序列化</h3>
    <table class="table table-striped table-bordered">
        <thead>
        <tr>
            <th>如果你想…</th>
            <th>所以,你写…</th>
            <th>Python调用…</th>
        </tr>
        </thead>
        <tbody>
        <tr>
            <td>对象副本</td>
            <td><code>copy.copy(x)</code></td>
            <td><code>x.__copy__()</code></td>
        </tr>
        <tr>
            <td>深拷贝</td>
            <td><code>copy.deepcopy(x)</code></td>
            <td><code>x.__deepcopy__()</code></td>
        </tr>
        <tr>
            <td>序列化一个对象</td>
            <td><code>pickle.dump(x, file)</code></td>
            <td><code>x.__getstate__()</code></td>
        </tr>
        <tr>
            <td>序列化一个对象</td>
            <td><code>pickle.dump(x, file)</code></td>
            <td><code>x.__reduce__()</code></td>
        </tr>
        <tr>
            <td>序列化一个对象</td>
            <td><code>pickle.dump(x, file, protocol_version)</code></td>
            <td><code>x.__reduce_ex__(protocol_version)</code></td>
        </tr>
        <tr>
            <td>取出恢复后的状态</td>
            <td><code>x = pickle.load(fp)</code></td>
            <td><code>x.__getnewargs__()</code></td>
        </tr>
        <tr>
            <td>取出恢复后的状态</td>
            <td><code>x = pickle.load(fp)</code></td>
            <td><code>x.__setstate__()</code></td>
        </tr>
        </tbody>
    </table>
    <h3><a id="with__171"></a>with 语句</h3>
    <p>with块限定了运行时上下文;在执行with语句时,&quot;进入&quot;上下文,并在执行块中的最后一个语句后&quot;退出&quot;上下文.</p>
    <table class="table table-striped table-bordered">
        <thead>
        <tr>
            <th>如果你想…</th>
            <th>所以,你写…</th>
            <th>Python调用…</th>
        </tr>
        </thead>
        <tbody>
        <tr>
            <td>进入with语句块</td>
            <td><code>with x:</code></td>
            <td><code>x.__enter__()</code></td>
        </tr>
        <tr>
            <td>退出with语句块</td>
            <td><code>with x:</code></td>
            <td><code>x.__exit__(exc_type, exc_value, traceback)</code></td>
        </tr>
        </tbody>
    </table>
    <h2><a id="_181"></a>真正深奥的东西</h2>
    <table class="table table-striped table-bordered">
        <thead>
        <tr>
            <th>如果你想…</th>
            <th>所以,你写…</th>
            <th>Python调用…</th>
        </tr>
        </thead>
        <tbody>
        <tr>
            <td>一个类的构造函数</td>
            <td><code>x = MyClass()</code></td>
            <td><code>x.__new__()</code></td>
        </tr>
        <tr>
            <td>一个类的析构函数</td>
            <td><code>del x</code></td>
            <td><code>x.__del__()</code></td>
        </tr>
        <tr>
            <td>只有一组特定的属性需要定义</td>
            <td>``</td>
            <td><code>x.__slots__()</code></td>
        </tr>
        <tr>
            <td>hash码</td>
            <td><code>hash(x)</code></td>
            <td><code>x.__hash__()</code></td>
        </tr>
        <tr>
            <td>获得一个属性的值</td>
            <td><code>x.color</code></td>
            <td><code>type(x).__dict__['color'].__get__(x, type(x))</code></td>
        </tr>
        <tr>
            <td>设置一个属性的值</td>
            <td><code>x.color = 'PapayaWhip'</code></td>
            <td><code>type(x).__dict__['color'].__set__(x, 'PapayaWhip')</code></td>
        </tr>
        <tr>
            <td>删除一个属性</td>
            <td><code>del x.color</code></td>
            <td><code>type(x).__dict__['color'].__del__(x)</code></td>
        </tr>
        <tr>
            <td>一个对象是否是你的一个类的实例</td>
            <td><code>isinstance(x, MyClass)</code></td>
            <td><code>MyClass.__instancecheck__(x)</code></td>
        </tr>
        <tr>
            <td>一个类是否是你的类的子类</td>
            <td><code>isinstance(C, MyClass)</code></td>
            <td><code>MyClass.__subclasscheck__(C)</code></td>
        </tr>
        <tr>
            <td>一个类是否是抽象基类的实例</td>
            <td><code>isinstance(C, MyABC)</code></td>
            <td><code>MyABC.__subclasshook__(C)</code></td>
        </tr>
        </tbody>
    </table>
    <p>Python正确调用<code>__del__()</code>特殊方法时非常复杂.为了完全理解它,你需要知道Python如何跟踪内存中的对象.这里有一篇关于<a
            href="https://www.electricmonk.nl/log/2008/07/07/python-destructor-and-garbage-collection-notes/">
        Python垃圾收集和类析构函数的好文章</a>.你还应该阅读关于<a
            href="https://docs.python.org/3/library/weakref.html">弱引用,weakref模块</a>,以及可能的<a
            href="https://docs.python.org/3/library/gc.html">gc模块</a>以获得更好的度量.</p>
</div>
<a href="https://github.com/ltoddy/ltoddy.github.io" target="_blank"><img
        style="position: absolute; top: 0; right: 0; border: 0;"
        src="https://camo.githubusercontent.com/38ef81f8aca64bb9a64448d0d70f1308ef5341ab/68747470733a2f2f73332e616d617a6f6e6177732e636f6d2f6769746875622f726962626f6e732f666f726b6d655f72696768745f6461726b626c75655f3132313632312e706e67"
        alt="Fork me on GitHub"
        data-canonical-src="https://s3.amazonaws.com/github/ribbons/forkme_right_darkblue_121621.png">
</a>
</body>
</html>
